anchor.diff:  
   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
   ;;;
  -;;; Class PROGV-AST.
  -
  -(defclass progv-ast (ast)
  -  ((%symbols-ast :initarg :symbols-ast :reader symbols-ast)
  -   (%vals-ast :initarg :vals-ast :reader vals-ast)
  -   (%body-ast :initarg :body-ast :reader body-ast)))
  -
  -(defun make-progv-ast (symbols-ast vals-ast body-ast)
  -  (make-instance 'progv-ast
  -    :symbols-ast symbols-ast
  -    :vals-ast vals-ast
  -    :body-ast body-ast))
  -
  -;;; FIXME: define a method on STREAM-DRAW-AST specialized to PROGV-AST.
  -
  -(defmethod children ((ast progv-ast))
  -  (append (symbols-ast ast)
  -	  (vals-ast ast)
  -	  (list (body-ast ast))))
  -
  -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  -;;;
   ;;; Class BLOCK-AST.
   
   (defclass block-ast (ast)
  
positive.code: 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Class MULTIPLE-VALUE-PROG1-AST.
  ;;;
  ;;; The HyperSpec says that MULTIPLE-VALUE-PROG1 takes at least one
  ;;; argument.  All the arguments are forms.  The first argument form
  ;;; is evaluated first and all the values are saved.  Then the
  ;;; remaining forms are evaluated from left to right and their values
  ;;; are discarded.  
  
  (defclass multiple-value-prog1-ast (ast)
    ((%first-ast :initarg :first-ast :reader first-ast)
     (%body-asts :initarg :body-asts :reader body-asts)))
  
  (defun make-multiple-value-prog1-ast (first-ast body-asts)
    (make-instance 'multiple-value-prog1-ast
      :first-ast first-ast
      :body-asts body-asts))
  
  (defmethod stream-draw-ast ((ast multiple-value-prog1-ast) stream)
    (declare (ignore stream))
    (error "don't know how to draw a multiple-value-prog1-ast yet"))
  
  (defmethod children ((ast multiple-value-prog1-ast))
    (cons (first-ast ast)
  	(body-asts ast)))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Class MULTIPLE-VALUE-CALL-AST.
  ;;; 
  ;;; The HyperSpec says that MULTIPLE-VALUE-CALL takes at least one
  ;;; argument.  All the arguments are forms.  The first argument is
  ;;; evaluated first, and the result must be a function.  Then the
  ;;; remaining forms are evaluated from left to right and all the
  ;;; values from each form are then used as arguments to the function.
  ;;; In other words, the number of arguments passed to the function are
  ;;; the sum of the number of values of each argument form (except the
  ;;; first).
  
  (defclass multiple-value-call-ast (ast)
    ((%callee-ast :initarg :callee-ast :reader callee-ast)
     (%argument-asts :initarg :argument-asts :reader argument-asts)))
  
  (defun make-multiple-value-call-ast (callee-ast argument-asts)
    (make-instance 'multiple-value-call-ast
      :callee-ast callee-ast
      :argument-asts argument-asts))
  
  ;;; FIXME: define a method on STREAM-DRAW-AST specialized to PROGV-AST.
  
  (defmethod children ((ast multiple-value-call-ast))
    (cons (callee-ast ast)
  	(argument-asts ast)))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Class PROGN-AST.
  
  (defclass progn-ast (ast)
  
negative.code: 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  ;;; Class IMMEDIATE-AST. 
  ;;;
  ;;; A IMMEDIATE-AST represents a constant expression that has fits in
  ;;; a word, and that has a value that is independent of the Lisp
  ;;; image, such as a fixnum, a character, or a short float.
  ;;;
  ;;; It is represented here as an unsigned integer between 0 and 2^w-1
  ;;; where w is the word size in bits. 
  
  (defclass immediate-ast (ast)
    ((%value :initarg :value :reader value)))
  
  (defun make-immediate-ast (value)
    (make-instance 'immediate-ast :value value))
  
  (defmethod stream-draw-ast ((ast immediate-ast) stream)
    (format stream "   ~a [label = \"~a\"];~%"
  	  (id ast)
  	  (value ast)))
  
  (defmethod children ((ast immediate-ast))
    '())
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  