anchor.diff:  ;;; Also, assign a label for the code for each lambda, and where
   ;;; possible, propogate it to the associated variable
   
  -(define-trivial-walker decompose-lambdas ())
  +(define-trivial-walker decompose-lambdas (begin))
   
   (define-decompose-lambdas (begin varrecs . body)
     (dolist (varrec varrecs)
       (varrec-attr-set! varrec 'lambda-label false))
  -  (decompose-lambdas-forms body))
  -
  -(define (decompose-lambda form attrs body)
  +  (decompose-lambdas-forms body form))
  +
  +(define-decompose-lambdas (lambda attrs body)
  +  (let* ((closure (attr-ref attrs 'closure)))
  +    (decompose-lambda form attrs closure body begin
  +                    (make-alloc-closure closure))))
  +
  +(define-decompose-lambdas (define varrec val)
  +  (if (and (eq? 'lambda (car val)) (not (varrec-written? varrec)))
  +      (decompose-define-lambda form varrec val begin)
  +      (decompose-lambdas val begin)))
  +
  +(define (decompose-define-lambda form varrec val begin)
  +  (let* ((closure (attr-ref (second val) 'closure)))
  +    (rplacd (cdr begin)
  +            (cons (list 'define varrec (make-alloc-closure closure))
  +                  (cddr begin)))
  +    (varrec-attr-set! varrec 'lambda-label
  +                      (decompose-lambda form (second val) closure (third val)
  +                                        begin (list 'ref varrec)))))
  +
  +(define (decompose-lambda form attrs closure body begin closure-form)
     (dolist (varrec (attr-ref attrs 'params))
       (varrec-attr-set! varrec 'lambda-label false))
  -  (decompose-lambdas body)
  +  (decompose-lambdas body begin)
   
     ;; turn (lambda attrs body) into
     ;; (fill-closure attrs (alloc-closure n) refs)
  -  (let* ((label (gen-label))
  -         (closure (attr-ref attrs 'closure)))
  +  (let* ((label (gen-label)))
       (overwrite-form form
         (quasiquote
           (fill-closure ((unquote-splicing attrs)
                           (label . (unquote label))
                           (body (unquote-splicing body)))
  -          (alloc-closure ((size . (unquote (length closure)))))
  +          (unquote closure-form)
             (unquote-splicing
               (mapfor (varrec closure)
                 (list 'ref (varrec-attr varrec 'source)))))))
       label))
   
  -(define-decompose-lambdas (lambda attrs body)
  -  (decompose-lambda form attrs body))
  -
  -(define-decompose-lambdas (define varrec val)
  -  (if (and (eq? 'lambda (car val)) (not (varrec-written? varrec)))
  -      (varrec-attr-set! varrec 'lambda-label
  -                        (decompose-lambda val (second val) (third val)))
  -      (decompose-lambdas val)))
  +(define (make-alloc-closure closure)
  +  (quasiquote (alloc-closure ((size . (unquote (length closure)))))))
   
   ;;; Produce a debug form
   
  
positive.code:   (dolist (varrec varrecs)
      (let* ((state (varrec-attr-remove varrec 'state)))
        (cond ((= state 6) (error "bad variable ~S" (car varrec)))
              ((or (= state 2) (= state 3))
               (rplacd (cdr form) (cons (list 'define varrec (quoted-unspecified))
                                        (cddr form)))))
        (varrec-attr-set! varrec 'access
  
negative.code:   (classify-variables program)
    (collect-closures program)
    (introduce-boxes program)
    (decompose-lambdas program false)
    (codegen-program program)
    ;(format~ true "~S~%" (debug-form program))
    )
  