anchor.diff:       (immediates (empty-immediates-environment)
         (virtual
          (closure
  -        (elim
  -         (inlined fundefs
  -          (flatten
  -           (beta (empty-beta-environment)
  -            (alpha2 (empty-alpha2-environment)
  -             (alpha1 (empty-alpha1-environment)
  -              (k-normal (empty-k-normal-environment)
  -               (expand form)))))))))))))))
  +        (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))
  
positive.code:   (flatten
     (beta-pic form)))
  
  (defun inlined-pic (form)
    (inlined (empty-inlined-environment)
      (flatten-pic form)))
  
  (defun elim-pic (form)
    (elim
     (inlined-pic form)))
  
  (defun closure-pic (form)
    (closure
     (elim-pic form)))
  
  (defun virtual-pic (form)
    (virtual
     (closure-pic form)))
  
  (defun immediates-pic (form)
    (immediates (empty-immediates-environment)
      (virtual-pic form)))
  
  (defun assign-pic (form)
    (assign (empty-register-environment) nil
     (immediates-pic form)))
  
  (defun emit-pic (form)
    (emit :tail
     (assign-pic form)))
  
  (defun output-pic (form)
    (output
     (emit-pic form)))
  
  
  ;;;
  
negative.code: ;;; Compilation
  ;;;
  
  (defun repeatedly (limit fun form)
    (if (= limit 0)
        form
        (let ((form1 (funcall fun form)))
          (if (equal form form1)
              form1
              (repeatedly (1- limit) fun form1)))))
  
  (defvar *limit* 1000)
  
  (defun compile-pic (form fundefs)
    (output
     (emit :tail
  