anchor.diff:  
   (defpsmacro loop (&rest args)
     (let* ((loop (parse-ps-loop (normalize-loop-keywords args)))
  -         (main (or (straightforward-form loop)
  -                   (parallel-form loop))))
  +         ;; Variable lifting to support initially/finally may
  +         ;; add to prologue, so compute main loop first.
  +         (main (or (parallel-form loop)
  +                   (straightforward-form loop))))
       `(,@(if (default-accum-var loop) '(with-lambda ()) '(progn))
           (with-prologue (,(prologue loop))
             ,@(initially loop)
  
positive.code:     (let ((test (when test-op
                    (with-local-var (v end state)
                      (list test-op var v)))))
        (push `(,var nil ,start (,op ,var ,(or by 1)) ,test :from) (iterations state)))))
  
  (defun for-= (var bindings state)
    (let ((start (eat state))
          (then (eat state :if :then)))
      (push (list var bindings start (or then start) nil :=) (iterations state))))
  
  (defun for-in (var bindings state)
    (with-local-var (arr (eat state) state)
  
negative.code:     (setf (tokens state) (append `(,index :from 0 :below ,(eat state)) (tokens state)))
      (for-clause state)))
  
  (flet ((while-or-until (tag var state)
           (let ((expr (eat state))
                 (test (ecase tag
                         (:while `(not ,var))
                         (:until var))))
             (push (list var nil expr expr test tag) (iterations state)))))
  
    (defun while-clause (state)
      (while-or-until :while (gensym) state))
  
    (defun until-clause (state)
      (while-or-until :until (gensym) state)))
  
  (defun body-clause (term state)
    (case term
      ((:when :unless)
  