anchor.diff:          (repeatedly *limit*
             #'(lambda (form)
                 (elim
  -               (inlined fundefs
  -                (flatten
  -                 (beta (empty-beta-environment) form)))))
  +               (flatten
  +                (beta (empty-beta-environment) form))))
             (alpha2 (empty-alpha2-environment)
              (alpha1 (empty-alpha1-environment)
               (k-normal (empty-k-normal-environment)
  -             (expand form))))))))))))
  +             (repeatedly *limit*
  +               #'(lambda (form)
  +                   (inlined fundefs form))
  +               (expand form)))))))))))))
   
   (defun expand-pic (form)
     (expand form))
   
  -(defun k-normal-pic (form)
  +(defun inlined-pic (form fundefs)
  +  (repeatedly *limit*
  +    #'(lambda (form)
  +        (inlined fundefs form))
  +    (expand-pic form)))
  +
  +(defun k-normal-pic (form fundefs)
     (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)
  +   (inlined-pic form fundefs)))
  +
  +(defun alpha-pic (form fundefs)
     (alpha2 (empty-alpha2-environment)
  -   (alpha1-pic form)))
  -
  -(defun alpha-pic (form)
  -  (alpha2-pic form))
  -
  -(defun beta-pic (form)
  +   (alpha1 (empty-alpha1-environment)
  +     (k-normal-pic form fundefs))))
  +
  +(defun beta-pic (form fundefs)
     (beta (empty-beta-environment)
  -   (alpha2-pic form)))
  -
  -(defun flatten-pic (form)
  +   (alpha-pic form fundefs)))
  +
  +(defun flatten-pic (form fundefs)
     (flatten
  -   (beta-pic form)))
  -
  -(defun inlined-pic (form fundefs)
  -  (inlined fundefs
  -    (flatten-pic form)))
  +   (beta-pic form fundefs)))
   
   (defun elim-pic (form fundefs)
     (elim
  
positive.code:       `(loop ,times
           ,body1))))
  
  (defun inlined-setreg (form)
    form)
  
  (defun inlined-apply (env form)
    (let ((operator (apply-operator form))
          (operands (apply-operands form)))
      (let ((inliner (inlined-environment-lookup operator env)))
        (if inliner
            (destructuring-bind (args expr) inliner
              (unless (= (length args) (length operands))
                (error "Invalid number of arguments: ~S~%" (length operands)))
              (alpha1 (empty-alpha1-environment)
               (inlined-apply% args operands expr)))
            `(,operator ,@operands)))))
  
  (defun inlined-apply% (args operands expr)
    (if args
        (destructuring-bind (arg . args1) args
          (destructuring-bind (operand . operands1) operands
            `(let ((,arg ,operand))
               ,(inlined-apply% args1 operands1 expr))))
        expr))
  
  
  ;;;
  
negative.code: 
  (defun inlined-environment-add-fundefs (fundefs env)
    (if fundefs
        (destructuring-bind ((name args body) . rest) fundefs
          (inlined-environment-add-fundefs rest
           (inlined-environment-add name args body env)))
        env))
  
  (defun inlined-environment-lookup (name env)
  