anchor.diff:                                      (cdddr varrec))))
             (varrec-attr-set! varrec 'closure-stack
                               (acons depth local-varrec closure-stack))
  -          (varrec-attr-set! varrec 'boxed (varrec-written? varrec))
  +          (varrec-attr-set! varrec 'boxed (varrec-quasi-written? varrec))
             (rplaca closure-cell (cons local-varrec (car closure-cell)))
             local-varrec))))
   
  
positive.code:   (form-attr-set! form 'self false)
    (classify-block-variables (attr-ref attrs 'params) 1 form))
   
  (define (varrec-written? varrec) (varrec-attr varrec 'written))
  
  ;;; Make the closure list for each lambda (i.e. variables unbound
  ;;; within the lambda body).  After this, lambdas look like:
  
negative.code: ;;; Classify all variables into read-only and potentially read-write
  ;;;
  ;;; I (0) - initial state
  ;;; r (1) - defined (and possibly read)
  ;;; w (2) - defined, and written
  ;;; R (3) - early read (encountered a potential read before the define)
  ;;; W (4) - early write (encountered a potential write before the define)
  ;;; ! (5) - error
  ;;;
  ;;;          I r w R W !
  ;;;
  ;;; define   r ! ! R W !
  ;;; ref      R r w R W !
  ;;; set!     W w w W W !
  
  
  ;;; A "written" boolean attribute is added to each varrec.
  
  (define-trivial-walker classify-variables ())
  
  (define varrec-define-state-table (make-vector-from-list '(1 5 5 3 4 5)))
  (define varrec-ref-state-table    (make-vector-from-list '(3 1 2 3 4 5)))
  (define varrec-set!-state-table   (make-vector-from-list '(4 2 2 4 4 5)))
  
  (define (update-varrec-state varrec table)
    (varrec-attr-set! varrec 'state
  