anchor.diff:  	   (make-instance 'constant-assignment-instruction
   	     :target temp
   	     :constant (value ast)
  -	     :next (make-instance 'out-instruction
  -	             :value-number 0
  -		     :variable temp
  -		     :next (make-instance 'value-count-instruction
  -		             :value-count 1
  -			     :next successor)))))
  +	     :next (make-instance 'leave-instruction
  +		     :sources (list temp)
  +		     :next successor))))
   	(t
   	 (make-instance 'constant-assignment-instruction
   	   :target (car value-context)
  -	   :value (value ast)
  +	   :constant (value ast)
   	   :next (nil-fill (cdr value-context) successor)))))
   
   (defmethod compile-ast ((ast if-ast) value-context successor)
  
positive.code:   ((%fun :initarg :fun :accessor fun)
     (%arguments :initarg :arguments :accessor arguments)))
  
  (defclass out-instruction (single-successor-instruction)
    ((%value-number :initarg :value-number :accessor value-number)
     (%variable :initarg :variable :accessor variable)))
  
  (defclass value-count-instruction (single-successor-instruction)
    ((%value-count :initarg :value-count :accessor value-count)))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Compile an abstract syntax tree.
  
  (defun new-temporary ()
    (make-instance 'variable-ast
      :binding (make-instance 'lexical-variable-entry
  			    :name 'temp)
      :type t))
  
  (defun nil-fill (value-context successor)
    (let ((next successor))
  
negative.code: 
  (defclass variable-assignment-instruction (single-successor-instruction)
    ((%target :initarg :target :accessor target)
     (%source :initarg :source :accessor source)))
  
  (defclass value-assignment-instruction (single-successor-instruction)
    ((%target :initarg :target :accessor target)
  