anchor.diff:    (> (length (iterations loop)) 1))
   
   (defun inits (loop)
  -  (mapcar (lambda (x) (subseq x 0 2)) (iterations loop)))
  +  (mapcar (lambda (x) (list (first x) (third x)))
  +          (iterations loop)))
   
   (defun steps (loop)
  -  (mapcar (lambda (x) `(setf ,(first x) ,(third x))) (iterations loop)))
  +  (mapcar (lambda (x) `(setf ,(first x) ,(fourth x)))
  +          (iterations loop)))
   
   (defun end-test (loop)
  -  (aif (loop :for (nil nil nil test) :in (iterations loop)
  +  (aif (loop :for (nil nil nil nil test) :in (iterations loop)
            :when test :collect test)
          (if (cdr it)
              (list 'not (cons 'or it))
              (cons 'not it))
          t))
   
  -(defun inner-body (loop)
  -  (if (multiple-fors? loop)
  -      (append (body loop)
  -              (loop :for (var nil step test) :in (iterations loop)
  -                :collect `(setf ,var ,step)
  -                :when test :collect `(when ,test (break))))
  -      (body loop)))
  +(defun wrap-with-dbinds (iterations forms)
  +  (if (null iterations)
  +      forms
  +      (wrap-with-dbinds
  +       (cdr iterations)
  +       (aif (second (car iterations))
  +            `((destructuring-bind ,it ,(first (car iterations)) ,@forms))
  +            forms))))
  +
  +(defun outer-body (loop)
  +  (wrap-with-dbinds
  +   (iterations loop)
  +   (if (multiple-fors? loop)
  +       (append (body loop)
  +               (loop :for (var nil nil step test) :in (iterations loop)
  +                 :collect `(setf ,var ,step)
  +                 :when test :collect `(when ,test (break))))
  +       (body loop))))
   
   (defun the-actual-loop (loop)
     (let ((body `(,@(awhen (during-first loop)
                            `((when ,(first-guard loop)
                                ,@it
                                (setf ,(first-guard loop) nil))))
  -                  ,@(inner-body loop)
  +                  ,@(outer-body loop)
                     ,@(when (during-last loop)
                             `((setf ,(last-guard loop) t))))))
       (if (multiple-fors? loop)
           `(while t ,@body)
           `(for ,(inits loop) (,(end-test loop)) ,(steps loop) ,@body))))
  +
  +(defun init-and-test (iterations form)
  +  (loop :for (var bindings init nil test) :in (reverse iterations) :do
  +    (when test
  +      (setf form `(unless ,test ,form)))
  +    (when bindings
  +      (setf form `(destructuring-bind ,bindings ,var ,form)))
  +    (setf form `(let ((,var ,init)) ,form)))
  +  form)
   
   (defun the-loop-form (loop)
     (let ((form `(progn
  
positive.code:   ((tokens :initarg :tokens :accessor tokens)
     (iterations :initform nil :accessor iterations)
     (prologue :initform nil :accessor prologue)
     (destructurings :initform nil :accessor destructurings)
     (initially :initform nil :accessor initially)
     (finally :initform nil :accessor finally)
     (during-first :initform nil :accessor during-first)
  
negative.code:                  ,@(awhen (during-last loop)
                            `((when ,(last-guard loop) ,@it)))
                   ,@(finally loop))))
      (if (multiple-fors? loop)
          (init-and-test (iterations loop) form)
          form)))
  
  (defpsmacro loop (&rest args)
    (let ((loop (parse-ps-loop (normalize-loop-keywords args))))
  