diff --git a/goof-impl.scm b/goof-impl.scm
index 2945b0e..718f280 100644
--- a/goof-impl.scm
+++ b/goof-impl.scm
@@ -180,55 +180,55 @@
         ((lets ...))
         ((accs ...))
         vars
-        ((checks ...))
+        checks
         ((refs ...))
         (finals ...)
-        ff ul uw ub uf clauses . body)
-      (cl orig name
-          ((lets ... new-lets ...))
-          ((accs ... (accvar accinit accupdate) ...))
-          vars
-          ((checks ... new-checks ...))
-          ((refs ... new-refs ...))
-          (finals ... new-finals ...)
-          ff ul uw ub uf clauses . body))
+        ff ul uw ((cur-ub ...) . ub-rest) uf clauses . body)
+     (cl orig name
+         ((lets ... new-lets ...))
+         ((accs ... (accvar accinit accupdate) ...))
+         vars
+         checks
+         ((refs ... new-refs ...))
+         (finals ... new-finals ...)
+         ff ul uw ((cur-ub ... new-checks ...) . ub-rest) uf clauses . body))
     ;; We have ONE subloop!
     ((_ (new-lets ...) ((accvar accinit accupdate) ...) (new-checks ...) (new-refs ...) (new-finals ...)
         orig name
         (lets ... (outermost-lets ...))
         ((accs ...) ((oldacc oldinit oldupdate) ...))
         vars
-        ((checks ...) . checks-rest)
+        checks
         ((refs ...) . refs-rest)
         (finals ...)
-        ff ul uw ub uf clauses . body)
-      (cl orig name
-          (lets ... (outermost-lets ... new-lets ...))
-          ((accs ... (accvar accvar accupdate) ...) ((oldacc oldinit oldupdate) ... (accvar accinit accvar) ...))
-          vars
-          ((checks ... new-checks ...) . checks-rest)
-          ((refs ... new-refs ...) . refs-rest)
-          (finals ... new-finals ...)
-          ff ul uw ub uf clauses . body))
+        ff ul uw ((cur-ub ...) . ub-rest) uf clauses . body)
+     (cl orig name
+         (lets ... (outermost-lets ... new-lets ...))
+         ((accs ... (accvar accvar accupdate) ...) ((oldacc oldinit oldupdate) ... (accvar accinit accvar) ...))
+         vars
+         checks
+         ((refs ... new-refs ...) . refs-rest)
+         (finals ... new-finals ...)
+         ff ul uw ((cur-ub ... new-checks ...) . ub-rest) uf clauses . body))
     ;; We have several subloops!
     ((_ (new-lets ...) ((accvar accinit accupdate) ...) (new-checks ...) (new-refs ...) (new-finals ...)
         orig name
         (lets ... (outermost-lets ...))
         ((accs ...) ((oldacc oldinit oldupdate) ...) ... ((oldestacc oldestinit oldestupdate) ...))
         vars
-        ((checks ...) . checks-rest)
+        checks
         ((refs ...) . refs-rest)
         (finals ...)
-        ff ul uw ub uf clauses . body)
+        ff ul uw ((cur-ub ...) . ub-rest) uf clauses . body)
      (cl orig name
-          (lets ... (outermost-lets ... new-lets ...))
-          ((accs ... (accvar accvar accupdate) ...) ((oldacc oldinit oldupdate) ... (accvar accvar accvar) ...) ...
-           ((oldestacc oldestinit oldestupdate) ... (accvar accinit accvar) ...))
-          vars
-          ((checks ... new-checks ...) . checks-rest)
-          ((refs ... new-refs ...) . refs-rest)
-          (finals ... new-finals ...)
-          ff ul uw ub uf clauses . body))))
+         (lets ... (outermost-lets ... new-lets ...))
+         ((accs ... (accvar accvar accupdate) ...) ((oldacc oldinit oldupdate) ... (accvar accvar accvar) ...) ...
+          ((oldestacc oldestinit oldestupdate) ... (accvar accinit accvar) ...))
+         vars
+         checks
+         ((refs ... new-refs ...) . refs-rest)
+         (finals ... new-finals ...)
+         ff ul uw ((cur-ub ... new-checks ...) . ub-rest) uf clauses . body))))
 
 ;; Integrating for clauses is not as involved, since they only want to be introduced into the current
 ;; loop. Any propagation of for finalizers (ff) is done by push-new-subloop
diff --git a/goof/iterators.scm b/goof/iterators.scm
index 2b227c3..9e8e2c0 100644
--- a/goof/iterators.scm
+++ b/goof/iterators.scm
@@ -447,18 +447,12 @@
         . rest))
     ((_ :acc ((var index) (expr (:length len))) n . rest)
      (vectoring  :acc ((var index) (expr (:length len) (:fill (if #f #f)))) n . rest))
-
-    ;; I am truly sorry. Currently this relies on pushing a :break clause WITHOUT
-    ;; the :when #t to ensure a subloop. It is the solution I would have used
-    ;; otherwise as well, but I would have wished for it to be more elegant.
-    ((_ :acc ((var index) (expr (:length len) (:fill f))) next
-        o n l a v c r fi ff ul uw ((ub ...) . ub-rest) uf . rest)
+    ((_ :acc ((var index) (expr (:length len) (:fill f))) next . rest)
      (next ((var (make-vector len f)))
            ((index 0 (begin (vector-set! var index expr) (+ index 1))))
-           ()
+           ((= index len))
            ()
            ((var var))
-           o n l a v c r fi ff ul uw ((ub ... (= index len)) . ub-rest) uf
            . rest))))
 
 ;;; Here starts generator clauses.