anchor.diff:      (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) (iterations state)))))
  +      (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))))
  +    (push (list var bindings start (or then start) nil :=) (iterations state))))
   
   (defun for-in (var bindings state)
     (with-local-var (arr (eat state) state)
  
positive.code:         (loop :while (tokens state) :do (clause state))
          (nreverse-loop-state state))))
  
  (defun multiple-fors? (loop)
    (> (length (iterations loop)) 1))
  
  (defun inits (loop)
    (mapcar (lambda (x) (list (first x) (third x)))
            (iterations loop)))
  
  (defun steps (loop)
    (mapcar (lambda (x) `(setf ,(first x) ,(fourth x)))
            (iterations loop)))
  
  (defun end-test (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 wrap-with-destructurings (iterations forms)
    (if (null iterations)
        forms
  
negative.code:                    ((:sum :count) 0)
                     ((:maximize :minimize) nil)
                     (:collect '(array)))))
      (prevar var initial state))
    (case kind
      (:sum `(incf ,var ,term))
      (:count `(unless (null ,term) (incf ,var)))
  