anchor.diff:  
   (defun load-level-location (location)
     (let ((count (- *depth* (lexical-depth (owner location)))))
  -    `(;; Load the lexical environment from the stack.
  -      "	move ebx, [ebp - 4]"
  +    `("	mov ebx, [ebp - 4]	; Load lexical environment from stack."
         ;; The environment is a list of levels.  Take the CDR as many
         ;; times as necessary to get to the right CONS cell of the list.
         ,@(loop repeat count
  -	      collect "	move ebx, [ebx + 3]")
  -      ;; Take the CAR to get to the level. 
  -      "	move ebx, [ebx - 1]"
  -      ;; The level is a heap object.  Load the contents vector. 
  -      "	move ebx, [ebx + 1]")))
  +	      collect "	mov ebx, [ebx + 3]	; CDR down a level.")
  +      "	mov ebx, [ebx - 1]	; CAR to get to the level vector."
  +      "	mov ebx, [ebx + 1]	; Load contents vector of level vector.")))
   
   (defun source/destination-operand (location)
     (format nil "[ebx + ~a]" (* 4 (1+ (index location)))))
  
positive.code: (defmethod load-input ((input sicl-env:lexical-location))
    (let ((count (- *depth* (lexical-depth (owner input)))))
      `(;; Load the lexical environment from the stack.
        "	move eax, [ebp - 4]"
        ;; The environment is a list of levels.  Take the CDR as many
        ;; times as necessary to get to the right CONS cell of the list.
        ,@(loop repeat count
  	      collect "	move eax, [eax + 3]")
        ;; Take the CAR to get to the level. 
        "	move eax, [eax - 1]"
        ;; The level is a heap object.  Load the contents vector. 
        "	move eax, [eax + 1]"
        ;; Load the appropriate element from the contents vector.
        ,(format nil "	move eax, [eax + ~a]"
  	       (* 4 (1+ (index input)))))))
  
  (defmethod load-input ((input sicl-mir:immediate-input))
    `(,(format nil "	move eax, ~a"
  	     (sicl-mir:value input))))
  
  (defmethod load-input ((input sicl-mir:external-input))
    `("	move eax, [ebp - 8]"
      ,(format nil "	move eax, [eax + ~a]"
  	     (* 4 (index input)))))
  
  (defun load-from-argument (i)
    `(,(format nil "	move eax, [edb + ~a]"
  	     (* 4 i))))
  
  (defun save-to-argument (i)
    `(,(format nil "	move [edb + ~a], eax"
  	     (* 4 i))))
  
  (defun save-result (location)
    (let ((count (- *depth* (lexical-depth (owner location)))))
      `(;; Load the lexical environment from the stack.
        "	move ebx, [ebp - 4]"
        ;; The environment is a list of levels.  Take the CDR as many
        ;; times as necessary to get to the right CONS cell of the list.
        ,@(loop repeat count
  	      collect "	move ebx, [ebx + 3]")
        ;; Take the CAR to get to the level. 
        "	move ebx, [ebx - 1]"
        ;; The level is a heap object.  Load the contents vector. 
        "	move ebx, [ebx + 1]"
        ;; Load the appropriate element from the contents vector.
        ,(format nil "	move [ebx + ~a], eax"
  	       (* 4 (1+ (index location)))))))
  
  (defgeneric codegen-instruction (instruction))
  
negative.code: 	(else-branch (codegen-instruction (cadr (successors instruction))))
  	(then-branch (codegen-instruction (car (successors instruction)))))
      `(,@(load-input (cadr (inputs instruction)))
        "	mov ebx, eax	; Second argument of ==."
        ,@(load-input (car (inputs instruction)))
        "	cmp eax, ebx	; Compare first and second argument of ==."
        ,(format nil "	jne ~a	; Go if not ==." label)
        ,@then-branch
        ,(format nil "~a:		; Come here if not ==." label)
        ,@else-branch)))
  	  
  (defmethod codegen-instruction
  