; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes
; in: LAMBDA (PGLOADER.SOURCES::ROW)
;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECOVERY_DATE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::PERIOD)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::GEAR)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::ADCLIP_SELECTIVE_FISHERY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::ESTIMATION_LEVEL)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_SITE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::RECORDED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::WEIGHT_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM LENGTH)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::LENGTH_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_CODE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::TAG_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_COLUMN_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM
;      PGLOADER.USER-SYMBOLS::SEQUENTIAL_ROW_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::CATCH_SAMPLE_ID)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLE_TYPE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MATURITY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_RUN)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK
;      PGLOADER.USER-SYMBOLS::SAMPLED_LENGTH_RANGE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_SEX)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLED_MARK)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::ESTIMATED_NUMBER)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-YEAR PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-BLANK PGLOADER.USER-SYMBOLS::SAMPLING_AGENCY)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::CHAR-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-DAY PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF LET PARSE-INTEGER 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 0 4)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 6 8)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: unable to
;   associate +/+ of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to
;   associate +/- of constants
; due to type uncertainty:
;   The first argument is a NUMBER, not a RATIONAL.

;     (PGLOADER.TRANSFORMS::GET-MONTH PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::DATE-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

; --> BLOCK IF 
; ==>
;   (SUBSEQ PGLOADER.TRANSFORMS::DATE-STRING 4 6)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (PGLOADER.TRANSFORMS::NULL-IF-NOT-NUM PGLOADER.USER-SYMBOLS::WEIGHT)
; --> BLOCK IF > 
; ==>
;   (LENGTH PGLOADER.TRANSFORMS::NUM-STRING)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (PGLOADER.TRANSFORMS::GET-WEEK PGLOADER.USER-SYMBOLS::RECOVERY_DATE)
; --> BLOCK IF LET IF 
; ==>
;   (> (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR 1 1) 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.

; --> BLOCK IF LET IF WRITE-TO-STRING SB-IMPL::STRINGIFY-OBJECT 1+ 
; ==>
;   (+
;    (PGLOADER.TRANSFORMS::WEEK-NUMBER PGLOADER.TRANSFORMS::WYEAR
;                                      PGLOADER.TRANSFORMS::WMONTH
;                                      PGLOADER.TRANSFORMS::WDAY)
;    1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; compilation unit finished
;   printed 89 notes