anchor.diff:                            (push `(,name (&rest args) (apply ,temp args)) labels)
                             `(progn (setf ,temp (ensure-function ,expr)) ',name)))
                          ((progn &body body)
  -                        `(progn ,@(mapcar #'expand-partially body)))
  +                        `(progn ,@(mapcar (lambda (form)
  +                                            (expand-partially form :top t))
  +                                          body)))
                          (((prog1 multiple-value-prog1) f &body body)
                           `(,(car form) ,(expand-partially f)
                             ,(expand-body body)))
  
positive.code: definitions."
    (multiple-value-bind (body decls) (parse-body orig-body)
      (let (vars hoisted-vars labels macros symbol-macros in-let? orig-form exprs)
        (declare (special in-let? orig-form))
        ;; The complexity here comes from three sources:
  
        ;; 1. Hoisting variable definitions with constant initforms. We
  
negative.code:                (expand-body (body)
                   "Shorthand for recursing on an implicit `progn'."
                   (expand-partially `(progn ,@body)))
                 (expand-partially (form &key top)
                   "Macro-expand FORM until it becomes a definition form or macro expansion stops."
                   (if (consp form)
                       (destructuring-case form
  