anchor.diff:      ;; Bind arguments to registers.
       (flet ((frob-arg (variable register)
                (when variable
  -               (cond (*enable-locals*
  -                      (let ((inst (make-instance 'bind-local-instruction
  -                                                 :ast variable
  -                                                 :value register)))
  -                        (emit inst)
  -                        (setf (gethash variable *variable-registers*) inst)))
  -                     (t
  -                      (setf (gethash variable *variable-registers*) register))))))
  +               (let ((inst (make-instance 'bind-local-instruction
  +                                          :ast variable
  +                                          :value register)))
  +                 (emit inst)
  +                 (setf (gethash variable *variable-registers*) inst)))))
         (frob-arg (lambda-information-fref-arg lambda) fref-reg)
         (frob-arg (lambda-information-closure-arg lambda) closure-reg)
         (frob-arg (lambda-information-count-arg lambda) count-reg)
  
positive.code:          (let ((value (cg-form init-form :value)))
             (when (not value)
               (return-from cg-form nil))
             (cond (*enable-locals*
                    (let ((inst (make-instance 'bind-local-instruction
                                               :ast var
                                               :value value)))
                      (emit inst)
                      (push (list :binding inst) *dynamic-stack*)
                      (setf (gethash var *variable-registers*) inst)))
                   (t
                    (let ((vreg (make-instance 'virtual-register)))
                      (emit (make-instance 'move-instruction
                                           :destination vreg
                                           :source value))
                      (setf (gethash var *variable-registers*) vreg))))))
      (let ((result (cg-form (ast-body form) result-mode)))
        (when (and *enable-locals*
                   result)
          (loop
             for (var init-form) in (reverse (ast-bindings form))
             do (emit (make-instance 'unbind-local-instruction
  
negative.code:                   (emit (make-instance 'constant-instruction
                                         :destination reg
                                         :value nil)))))
        (loop
           for var in (ast-bindings form)
           for reg in regs
           for inst = (make-instance 'bind-local-instruction
                                     :ast var
                                     :value reg)
           do
             (emit inst)
             (push (list :binding inst) *dynamic-stack*)
             (setf (gethash var *variable-registers*) inst))
        (let ((result (cg-form (ast-body form) result-mode)))
          (when result
            (dolist (var (reverse (ast-bindings form)))
              (emit (make-instance 'unbind-local-instruction
                                   :local (gethash var *variable-registers*)))))
  