anchor.diff:  (defun program-fundefs (program)
     (loop for name in (program-names program)
        collect
  -       (destructuring-bind (args body body1 insts) (program-by-name program name)
  -         (declare (ignore body insts))
  -         (list name args body1))))
  +       (destructuring-bind (args body insts) (program-by-name program name)
  +         (declare (ignore insts))
  +         (let ((body1 (expand body)))
  +           (list name args body1)))))
   
   (defun program-fundefs-excluding (program name)
     (remove name (program-fundefs program) :key #'car))
  
positive.code:         (repeatedly *limit*
            #'(lambda (form)
                (elim
                 (inlined fundefs
                  (flatten
                   (beta (empty-beta-environment) form)))))
            (alpha2 (empty-alpha2-environment)
             (alpha1 (empty-alpha1-environment)
              (k-normal (empty-k-normal-environment)
               (expand form))))))))))))
  
  (defun expand-pic (form)
    (expand form))
  
  (defun k-normal-pic (form)
    (k-normal (empty-k-normal-environment)
     (expand-pic form)))
  
  (defun alpha1-pic (form)
    (alpha1 (empty-alpha1-environment)
     (k-normal-pic form)))
  
  (defun alpha2-pic (form)
    (alpha2 (empty-alpha2-environment)
     (alpha1-pic form)))
  
  (defun alpha-pic (form)
    (alpha2-pic form))
  
  (defun beta-pic (form)
    (beta (empty-beta-environment)
     (alpha2-pic form)))
  
  (defun flatten-pic (form)
    (flatten
     (beta-pic form)))
  
  (defun inlined-pic (form fundefs)
    (inlined fundefs
      (flatten-pic form)))
  
  (defun elim-pic (form fundefs)
    (elim
  
negative.code: (defun inlined-reference (form)
    form)
  
  (defun inlined-sub (env form)
    (let ((expr1 (sub-expr1 form))
          (expr2 (sub-expr2 form)))
      (let ((expr1% (inlined% env expr1))
            (expr2% (inlined% env expr2)))
        `(- ,expr1% ,expr2%))))
  
  (defun inlined-ifeq (env form)
    (let ((lhs (ifeq-lhs form))
          (rhs (ifeq-rhs form))
          (then (ifeq-then form))
          (else (ifeq-else form)))
      (let ((lhs1 (inlined% env lhs))
            (rhs1 (inlined% env rhs))
            (then1 (inlined% env then))
            (else1 (inlined% env else)))
        `(if (= ,lhs1 ,rhs1)
             ,then1
             ,else1))))
  
  (defun inlined-let (env form)
    (let ((var (let-var form))
  