anchor.diff:  
   (define-walker assign-indices-aux (index) ignore-domain)
   
  -(define-assign-indices-aux (let varrecs . body)
  +(define-assign-indices-aux (let varrecs body)
     (assign-indices-aux-recurse form
                                 (assign-varrec-indices varrecs 'local index)))
   
  -(define-assign-indices-aux (lambda attrs . body)
  +(define-assign-indices-aux (lambda attrs body)
     (assign-varrec-indices (attr-ref attrs 'closure) 'closure 0)
     (assign-varrec-indices (form-attr form 'params) 'param 0)
     (assign-indices-aux-recurse form 0))
  
positive.code:     (varrec-attr-set! varrec 'written
                        (= 2 (varrec-attr-remove varrec 'state)))))
  
  (define-classify-variables (let varrecs . body)
    (classify-block-variables varrecs 1 form))
  
  (define-classify-variables (lambda attrs . body)
    (classify-block-variables (attr-ref attrs 'params) 0 form))
   
  ;;; Now definition information is captured in the lets, replace
  
negative.code:     (varrec-attr-set! varrec 'origin false)
      (varrec-attr-remove varrec 'closure-stack)))
  
  (define-collect-closures-aux (let varrecs body)
    (collect-closures-body form varrecs depth closure-cell))
  
  (define-collect-closures-aux (lambda attrs body)
    (let* ((local-closure-cell (cons () ())))
      (collect-closures-body form (attr-ref attrs 'params)
                             (1+ depth) local-closure-cell)
  