diff --git a/pkgs/typed-racket-pkgs/typed-racket-lib/typed-racket/optimizer/vector.rkt b/pkgs/typed-racket-pkgs/typed-racket-lib/typed-racket/optimizer/vector.rkt
index c1a6ef4874..7b297676e5 100644
--- a/pkgs/typed-racket-pkgs/typed-racket-lib/typed-racket/optimizer/vector.rkt
+++ b/pkgs/typed-racket-pkgs/typed-racket-lib/typed-racket/optimizer/vector.rkt
@@ -11,115 +11,99 @@
 
 (provide vector-opt-expr)
 
+(define-literal-syntax-class vector-length-proc
+  (vector-length unsafe-vector-length unsafe-vector*-length))
+
+(define-literal-syntax-class vector-length)
+(define-literal-syntax-class vector-ref)
+(define-literal-syntax-class vector-set!)
+(define-literal-syntax-class flvector-length)
+(define-unsafe-syntax-class flvector-ref)
+(define-unsafe-syntax-class flvector-set!)
 
 (define-syntax-class vector-op
   #:commit
   ;; we need the non-* versions of these unsafe operations to be chaperone-safe
-  (pattern (~literal vector-ref)  #:with unsafe #'unsafe-vector-ref  #:with unsafe-no-impersonator #'unsafe-vector*-ref)
-  (pattern (~literal vector-set!) #:with unsafe #'unsafe-vector-set! #:with unsafe-no-impersonator #'unsafe-vector*-set!))
-(define-syntax-class flvector-op
-  #:commit
-  (pattern (~literal flvector-ref)  #:with unsafe #'unsafe-flvector-ref)
-  (pattern (~literal flvector-set!) #:with unsafe #'unsafe-flvector-set!))
+  (pattern :vector-ref^  #:with unsafe #'unsafe-vector-ref  #:with unsafe-no-impersonator #'unsafe-vector*-ref)
+  (pattern :vector-set!^ #:with unsafe #'unsafe-vector-set! #:with unsafe-no-impersonator #'unsafe-vector*-set!))
+(define-merged-syntax-class flvector-op (flvector-ref^ flvector-set!^))
 
 (define-syntax-class known-length-vector-expr
   #:commit
-  (pattern e:expr
-           #:when (match (type-of #'e)
-                    [(tc-result1: (HeterogeneousVector: _)) #t]
-                    [_ #f])
-           #:with opt ((optimize) #'e)))
+  #:attributes (len opt)
+  (pattern (~and e :opt-expr)
+    #:attr tys (match (type-of #'e)
+                 [(tc-result1: (HeterogeneousVector: tys)) tys]
+                 [_ #f])
+    #:when (attribute tys)
+    #:attr len (length (attribute tys))))
 
 (define-syntax-class vector-opt-expr
   #:commit
+  #:literal-sets (kernel-literals)
+  #:attributes (opt)
   ;; vector-length of a known-length vector
-  (pattern (#%plain-app (~and op (~or (~literal vector-length)
-                                      (~literal unsafe-vector-length)
-                                      (~literal unsafe-vector*-length)))
-                        v:known-length-vector-expr)
-           #:with opt
-           (begin (log-optimization "known-length vector-length"
-                                    "Static vector length computation."
-                                    this-syntax)
-                  (add-disappeared-use #'op)
-                  (match (type-of #'v)
-                    [(tc-result1: (HeterogeneousVector: es))
-                     #`(let () v.opt #,(length es))]))) ; v may have side effects
-  ;; we can optimize vector-length on all vectors.
+  (pattern (#%plain-app op:vector-length-proc v:known-length-vector-expr)
+    #:do [(log-opt "known-length vector-length" "Static vector length computation.")]
+    ; v may have side effects
+    #:with opt #`(let () v.opt #,(attribute v.len)))
+  ;; optimize vector-length on all vectors.
   ;; since the program typechecked, we know the arg is a vector.
   ;; we can optimize no matter what.
-  (pattern (#%plain-app (~and op (~literal vector-length)) v:expr)
-           #:with opt
-           (begin (log-optimization "vector-length" "Vector check elimination." this-syntax)
-                  (add-disappeared-use #'op)
-                  #`(unsafe-vector-length #,((optimize) #'v))))
+  (pattern (#%plain-app op:vector-length^ v:opt-expr)
+    #:do [(log-opt "vector-length" "Vector check elimination.")]
+    #:with opt #'(unsafe-vector-length v.opt))
   ;; same for flvector-length
-  (pattern (#%plain-app (~and op (~literal flvector-length)) v:expr)
-           #:with opt
-           (begin (log-optimization "flvector-length" "Float vector check elimination." this-syntax)
-                  (add-disappeared-use #'op)
-                  #`(unsafe-flvector-length #,((optimize) #'v))))
+  (pattern (#%plain-app op:flvector-length^ v:opt-expr)
+    #:do [(log-opt "flvector-length" "Float vector check elimination.")]
+    #:with opt #'(unsafe-flvector-length v.opt))
   ;; we can optimize vector ref and set! on vectors of known length if we know
   ;; the index is within bounds (for now, literal or singleton type)
-  (pattern (#%plain-app op:vector-op v:known-length-vector-expr i:expr new:expr ...)
-           #:when (let ((len (match (type-of #'v)
-                               [(tc-result1: (HeterogeneousVector: es)) (length es)]
-                               [_ 0]))
-                        (ival (or (syntax-parse #'i [((~literal quote) i:number) (syntax-e #'i)] [_ #f])
-                                  (match (type-of #'i)
-                                    [(tc-result1: (Value: (? number? i))) i]
-                                    [_ #f]))))
-                    (and (integer? ival) (exact? ival) (<= 0 ival (sub1 len))))
-           #:with opt
-           (begin (log-optimization "vector" "Vector bounds checking elimination." this-syntax)
-                  (add-disappeared-use #'op)
-                  #`(op.unsafe v.opt #,((optimize) #'i)
-                               #,@(stx-map (optimize) #'(new ...)))))
+  (pattern (#%plain-app op:vector-op v:known-length-vector-expr i:value-expr new:opt-expr ...)
+    #:when (<= 0 (attribute i.val) (sub1 (attribute v.len)))
+    #:do [(log-opt "vector" "Vector bounds checking elimination.")]
+    #:with opt #'(op.unsafe v.opt i.opt new.opt ...))
 
   ;; we can do the bounds checking separately, to eliminate some of the checks
-  (pattern (#%plain-app op:vector-op v:expr i:fixnum-expr new:expr ...)
-           #:with opt
-           (begin (log-optimization "vector partial bounds checking elimination"
-                                    "Partial bounds checking elimination."
-                                    this-syntax)
-                  (add-disappeared-use #'op)
-                  (let ([safe-fallback #`(op new-v new-i #,@(stx-map (optimize) #'(new ...)))]
-                        [i-known-nonneg? (subtypeof? #'i -NonNegFixnum)])
-                    #`(let ([new-i #,((optimize) #'i)]
-                            [new-v #,((optimize) #'v)])
-                        ;; do the impersonator check up front, to avoid doing it twice (length and op)
-                        (if (impersonator? new-v)
-                            (if #,(let ([one-sided #'(unsafe-fx< new-i (unsafe-vector*-length new-v))])
-                                    (if i-known-nonneg?
-                                        ;; we know it's nonnegative, one-sided check
-                                        one-sided
-                                        #`(and (unsafe-fx>= new-i 0)
-                                               #,one-sided)))
-                                (op.unsafe new-v new-i #,@(stx-map (optimize) #'(new ...)))
-                                #,safe-fallback) ; will error. to give the right error message
-                            ;; not an impersonator, can use unsafe-vector* ops
-                            (if #,(let ([one-sided #'(unsafe-fx< new-i (unsafe-vector-length new-v))])
-                                    (if i-known-nonneg?
-                                        one-sided
-                                        #`(and (unsafe-fx>= new-i 0)
-                                               #,one-sided)))
-                                (op.unsafe-no-impersonator new-v new-i #,@(stx-map (optimize) #'(new ...)))
-                                #,safe-fallback))))))
+  (pattern (#%plain-app op:vector-op v:opt-expr i:fixnum-expr new:opt-expr ...)
+    #:do [(log-opt "vector partial bounds checking elimination"
+                   "Partial bounds checking elimination.")]
+    #:with opt
+      (let ([safe-fallback #'(op new-v new-i new.opt ...)]
+            [i-known-nonneg? (subtypeof? #'i -NonNegFixnum)])
+        #`(let ([new-i i.opt]
+                [new-v v.opt])
+            ;; do the impersonator check up front, to avoid doing it twice (length and op)
+            (if (impersonator? new-v)
+                (if #,(let ([one-sided #'(unsafe-fx< new-i (unsafe-vector*-length new-v))])
+                        (if i-known-nonneg?
+                            ;; we know it's nonnegative, one-sided check
+                            one-sided
+                            #`(and (unsafe-fx>= new-i 0)
+                                   #,one-sided)))
+                    (op.unsafe new-v new-i new.opt ...)
+                    #,safe-fallback) ; will error. to give the right error message
+                ;; not an impersonator, can use unsafe-vector* ops
+                (if #,(let ([one-sided #'(unsafe-fx< new-i (unsafe-vector-length new-v))])
+                        (if i-known-nonneg?
+                            one-sided
+                            #`(and (unsafe-fx>= new-i 0)
+                                   #,one-sided)))
+                    (op.unsafe-no-impersonator new-v new-i new.opt ...)
+                    #,safe-fallback)))))
   ;; similarly for flvectors
-  (pattern (#%plain-app op:flvector-op v:expr i:fixnum-expr new:expr ...)
-           #:with opt
-           (begin (log-optimization "flvector partial bounds checking elimination"
-                                    "Partial bounds checking elimination."
-                                    this-syntax)
-                  (add-disappeared-use #'op)
-                  (let ([safe-fallback #`(op new-v new-i #,@(stx-map (optimize) #'(new ...)))]
-                        [i-known-nonneg? (subtypeof? #'i -NonNegFixnum)])
-                    #`(let ([new-i #,((optimize) #'i)]
-                            [new-v #,((optimize) #'v)])
-                        (if #,(let ([one-sided #'(unsafe-fx< new-i (unsafe-flvector-length new-v))])
-                                (if i-known-nonneg?
-                                    one-sided
-                                    #`(and (unsafe-fx>= new-i 0)
-                                           #,one-sided)))
-                            (op.unsafe new-v new-i #,@(stx-map (optimize) #'(new ...)))
-                            #,safe-fallback))))))
+  (pattern (#%plain-app op:flvector-op v:opt-expr i:fixnum-expr new:opt-expr ...)
+    #:do [(log-opt "flvector partial bounds checking elimination"
+                   "Partial bounds checking elimination.")]
+    #:with opt
+      (let ([safe-fallback #'(op new-v new-i new.opt ...)]
+            [i-known-nonneg? (subtypeof? #'i -NonNegFixnum)])
+        #`(let ([new-i i.opt]
+                [new-v v.opt])
+            (if #,(let ([one-sided #'(unsafe-fx< new-i (unsafe-flvector-length new-v))])
+                    (if i-known-nonneg?
+                        one-sided
+                        #`(and (unsafe-fx>= new-i 0)
+                               #,one-sided)))
+                (op.unsafe new-v new-i new.opt ...)
+                #,safe-fallback)))))
diff --git a/pkgs/typed-racket-pkgs/typed-racket-test/tests/typed-racket/optimizer/tests/vector-sum.rkt b/pkgs/typed-racket-pkgs/typed-racket-test/tests/typed-racket/optimizer/tests/vector-sum.rkt
index ea0e8dc815..12e89b53ae 100644
--- a/pkgs/typed-racket-pkgs/typed-racket-test/tests/typed-racket/optimizer/tests/vector-sum.rkt
+++ b/pkgs/typed-racket-pkgs/typed-racket-test/tests/typed-racket/optimizer/tests/vector-sum.rkt
@@ -1,92 +1,76 @@
 #;#;
 #<<END
-TR opt: vector-sum.rkt 102:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
-TR opt: vector-sum.rkt 102:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
-TR opt: vector-sum.rkt 102:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
-TR opt: vector-sum.rkt 102:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
-TR opt: vector-sum.rkt 102:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
-TR opt: vector-sum.rkt 102:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
-TR opt: vector-sum.rkt 102:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
-TR opt: vector-sum.rkt 102:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
-TR opt: vector-sum.rkt 102:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
-TR opt: vector-sum.rkt 102:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
-TR opt: vector-sum.rkt 102:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
-TR opt: vector-sum.rkt 102:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
-TR opt: vector-sum.rkt 102:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
-TR opt: vector-sum.rkt 102:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
-TR opt: vector-sum.rkt 102:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
-TR opt: vector-sum.rkt 102:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
-TR opt: vector-sum.rkt 103:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- binary fixnum comp
-TR opt: vector-sum.rkt 103:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- binary fixnum comp
-TR opt: vector-sum.rkt 103:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- binary fixnum comp
-TR opt: vector-sum.rkt 103:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- binary fixnum comp
-TR opt: vector-sum.rkt 103:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- dead else branch
-TR opt: vector-sum.rkt 103:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- dead else branch
-TR opt: vector-sum.rkt 103:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- dead else branch
-TR opt: vector-sum.rkt 103:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- dead else branch
-TR opt: vector-sum.rkt 103:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- dead else branch
-TR opt: vector-sum.rkt 103:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- dead else branch
-TR opt: vector-sum.rkt 103:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- dead else branch
-TR opt: vector-sum.rkt 103:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- dead else branch
-TR opt: vector-sum.rkt 103:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- fixnum bounded expr
-TR opt: vector-sum.rkt 103:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- fixnum bounded expr
-TR opt: vector-sum.rkt 103:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- fixnum bounded expr
-TR opt: vector-sum.rkt 103:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- fixnum bounded expr
-TR opt: vector-sum.rkt 104:21 (sin (exact->inexact i)) -- unary float
-TR opt: vector-sum.rkt 104:21 (sin (exact->inexact i)) -- unary float
-TR opt: vector-sum.rkt 104:21 (sin (exact->inexact i)) -- unary float
-TR opt: vector-sum.rkt 104:21 (sin (exact->inexact i)) -- unary float
-TR opt: vector-sum.rkt 104:21 (sin (exact->inexact i)) -- unary float
-TR opt: vector-sum.rkt 104:21 (sin (exact->inexact i)) -- unary float
-TR opt: vector-sum.rkt 104:21 (sin (exact->inexact i)) -- unary float
-TR opt: vector-sum.rkt 104:21 (sin (exact->inexact i)) -- unary float
-TR opt: vector-sum.rkt 104:21 (sin (exact->inexact i)) -- unary float
-TR opt: vector-sum.rkt 104:21 (sin (exact->inexact i)) -- unary float
-TR opt: vector-sum.rkt 104:21 (sin (exact->inexact i)) -- unary float
-TR opt: vector-sum.rkt 104:21 (sin (exact->inexact i)) -- unary float
-TR opt: vector-sum.rkt 104:26 (exact->inexact i) -- fixnum to float
-TR opt: vector-sum.rkt 104:26 (exact->inexact i) -- fixnum to float
-TR opt: vector-sum.rkt 104:26 (exact->inexact i) -- fixnum to float
-TR opt: vector-sum.rkt 104:26 (exact->inexact i) -- fixnum to float
-TR opt: vector-sum.rkt 104:26 (exact->inexact i) -- fixnum to float
-TR opt: vector-sum.rkt 104:26 (exact->inexact i) -- fixnum to float
-TR opt: vector-sum.rkt 104:26 (exact->inexact i) -- fixnum to float
-TR opt: vector-sum.rkt 104:26 (exact->inexact i) -- fixnum to float
-TR opt: vector-sum.rkt 104:26 (exact->inexact i) -- fixnum to float
-TR opt: vector-sum.rkt 104:26 (exact->inexact i) -- fixnum to float
-TR opt: vector-sum.rkt 104:26 (exact->inexact i) -- fixnum to float
-TR opt: vector-sum.rkt 104:26 (exact->inexact i) -- fixnum to float
-TR opt: vector-sum.rkt 104:4 (vector-set! v i (sin (exact->inexact i))) -- vector partial bounds checking elimination
-TR opt: vector-sum.rkt 104:4 (vector-set! v i (sin (exact->inexact i))) -- vector partial bounds checking elimination
-TR opt: vector-sum.rkt 104:4 (vector-set! v i (sin (exact->inexact i))) -- vector partial bounds checking elimination
-TR opt: vector-sum.rkt 104:4 (vector-set! v i (sin (exact->inexact i))) -- vector partial bounds checking elimination
-TR opt: vector-sum.rkt 105:15 sum -- dead else branch
-TR opt: vector-sum.rkt 105:15 sum -- dead else branch
-TR opt: vector-sum.rkt 105:15 sum -- dead else branch
-TR opt: vector-sum.rkt 105:15 sum -- dead else branch
-TR opt: vector-sum.rkt 105:15 sum -- dead else branch
-TR opt: vector-sum.rkt 105:15 sum -- dead else branch
-TR opt: vector-sum.rkt 105:15 sum -- dead else branch
-TR opt: vector-sum.rkt 105:15 sum -- dead else branch
-TR opt: vector-sum.rkt 105:2 (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i))) -- binary fixnum comp
-TR opt: vector-sum.rkt 105:2 (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i))) -- binary fixnum comp
-TR opt: vector-sum.rkt 105:2 (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i))) -- binary fixnum comp
-TR opt: vector-sum.rkt 105:2 (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i))) -- binary fixnum comp
-TR opt: vector-sum.rkt 105:2 (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i))) -- fixnum bounded expr
-TR opt: vector-sum.rkt 105:2 (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i))) -- fixnum bounded expr
-TR opt: vector-sum.rkt 105:2 (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i))) -- fixnum bounded expr
-TR opt: vector-sum.rkt 105:2 (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i))) -- fixnum bounded expr
-TR opt: vector-sum.rkt 107:11 (vector-ref v i) -- vector partial bounds checking elimination
-TR opt: vector-sum.rkt 107:11 (vector-ref v i) -- vector partial bounds checking elimination
-TR opt: vector-sum.rkt 107:11 (vector-ref v i) -- vector partial bounds checking elimination
-TR opt: vector-sum.rkt 107:11 (vector-ref v i) -- vector partial bounds checking elimination
-TR opt: vector-sum.rkt 107:4 (+ sum (vector-ref v i)) -- binary float
-TR opt: vector-sum.rkt 107:4 (+ sum (vector-ref v i)) -- binary float
-TR opt: vector-sum.rkt 107:4 (+ sum (vector-ref v i)) -- binary float
-TR opt: vector-sum.rkt 107:4 (+ sum (vector-ref v i)) -- binary float
-TR opt: vector-sum.rkt 93:0 #%module-begin -- dead else branch
-TR opt: vector-sum.rkt 93:0 #%module-begin -- dead else branch
-TR opt: vector-sum.rkt 93:0 #%module-begin -- dead else branch
+TR opt: vector-sum.rkt 77:0 #%module-begin -- dead else branch
+TR opt: vector-sum.rkt 77:0 #%module-begin -- dead else branch
+TR opt: vector-sum.rkt 77:0 #%module-begin -- dead else branch
+TR opt: vector-sum.rkt 86:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
+TR opt: vector-sum.rkt 86:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
+TR opt: vector-sum.rkt 86:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
+TR opt: vector-sum.rkt 86:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
+TR opt: vector-sum.rkt 86:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
+TR opt: vector-sum.rkt 86:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
+TR opt: vector-sum.rkt 86:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
+TR opt: vector-sum.rkt 86:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
+TR opt: vector-sum.rkt 86:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
+TR opt: vector-sum.rkt 86:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
+TR opt: vector-sum.rkt 86:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
+TR opt: vector-sum.rkt 86:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
+TR opt: vector-sum.rkt 86:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
+TR opt: vector-sum.rkt 86:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
+TR opt: vector-sum.rkt 86:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
+TR opt: vector-sum.rkt 86:0 (for ((i (in-range 1))) (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i)))) -- dead else branch
+TR opt: vector-sum.rkt 87:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- binary fixnum comp
+TR opt: vector-sum.rkt 87:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- binary fixnum comp
+TR opt: vector-sum.rkt 87:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- binary fixnum comp
+TR opt: vector-sum.rkt 87:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- binary fixnum comp
+TR opt: vector-sum.rkt 87:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- dead else branch
+TR opt: vector-sum.rkt 87:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- dead else branch
+TR opt: vector-sum.rkt 87:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- dead else branch
+TR opt: vector-sum.rkt 87:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- dead else branch
+TR opt: vector-sum.rkt 87:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- dead else branch
+TR opt: vector-sum.rkt 87:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- dead else branch
+TR opt: vector-sum.rkt 87:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- dead else branch
+TR opt: vector-sum.rkt 87:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- dead else branch
+TR opt: vector-sum.rkt 87:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- fixnum bounded expr
+TR opt: vector-sum.rkt 87:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- fixnum bounded expr
+TR opt: vector-sum.rkt 87:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- fixnum bounded expr
+TR opt: vector-sum.rkt 87:2 (for: ((i : Nonnegative-Fixnum (in-range l))) (vector-set! v i (sin (exact->inexact i)))) -- fixnum bounded expr
+TR opt: vector-sum.rkt 88:21 (sin (exact->inexact i)) -- unary float
+TR opt: vector-sum.rkt 88:21 (sin (exact->inexact i)) -- unary float
+TR opt: vector-sum.rkt 88:21 (sin (exact->inexact i)) -- unary float
+TR opt: vector-sum.rkt 88:21 (sin (exact->inexact i)) -- unary float
+TR opt: vector-sum.rkt 88:26 (exact->inexact i) -- fixnum to float
+TR opt: vector-sum.rkt 88:26 (exact->inexact i) -- fixnum to float
+TR opt: vector-sum.rkt 88:26 (exact->inexact i) -- fixnum to float
+TR opt: vector-sum.rkt 88:26 (exact->inexact i) -- fixnum to float
+TR opt: vector-sum.rkt 88:4 (vector-set! v i (sin (exact->inexact i))) -- vector partial bounds checking elimination
+TR opt: vector-sum.rkt 88:4 (vector-set! v i (sin (exact->inexact i))) -- vector partial bounds checking elimination
+TR opt: vector-sum.rkt 88:4 (vector-set! v i (sin (exact->inexact i))) -- vector partial bounds checking elimination
+TR opt: vector-sum.rkt 88:4 (vector-set! v i (sin (exact->inexact i))) -- vector partial bounds checking elimination
+TR opt: vector-sum.rkt 89:15 sum -- dead else branch
+TR opt: vector-sum.rkt 89:15 sum -- dead else branch
+TR opt: vector-sum.rkt 89:15 sum -- dead else branch
+TR opt: vector-sum.rkt 89:15 sum -- dead else branch
+TR opt: vector-sum.rkt 89:15 sum -- dead else branch
+TR opt: vector-sum.rkt 89:15 sum -- dead else branch
+TR opt: vector-sum.rkt 89:15 sum -- dead else branch
+TR opt: vector-sum.rkt 89:15 sum -- dead else branch
+TR opt: vector-sum.rkt 89:2 (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i))) -- binary fixnum comp
+TR opt: vector-sum.rkt 89:2 (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i))) -- binary fixnum comp
+TR opt: vector-sum.rkt 89:2 (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i))) -- binary fixnum comp
+TR opt: vector-sum.rkt 89:2 (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i))) -- binary fixnum comp
+TR opt: vector-sum.rkt 89:2 (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i))) -- fixnum bounded expr
+TR opt: vector-sum.rkt 89:2 (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i))) -- fixnum bounded expr
+TR opt: vector-sum.rkt 89:2 (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i))) -- fixnum bounded expr
+TR opt: vector-sum.rkt 89:2 (for/fold: ((sum : Float 0.0)) ((i : Nonnegative-Fixnum (in-range l))) (+ sum (vector-ref v i))) -- fixnum bounded expr
+TR opt: vector-sum.rkt 91:11 (vector-ref v i) -- vector partial bounds checking elimination
+TR opt: vector-sum.rkt 91:11 (vector-ref v i) -- vector partial bounds checking elimination
+TR opt: vector-sum.rkt 91:11 (vector-ref v i) -- vector partial bounds checking elimination
+TR opt: vector-sum.rkt 91:11 (vector-ref v i) -- vector partial bounds checking elimination
+TR opt: vector-sum.rkt 91:4 (+ sum (vector-ref v i)) -- binary float
+TR opt: vector-sum.rkt 91:4 (+ sum (vector-ref v i)) -- binary float
+TR opt: vector-sum.rkt 91:4 (+ sum (vector-ref v i)) -- binary float
+TR opt: vector-sum.rkt 91:4 (+ sum (vector-ref v i)) -- binary float
 END
 ""