anchor.diff:  
   (defgeneric predecessors (instruction-or-info))
   (defgeneric (setf predecessors) (new instruction-or-info))
  -(defgeneric procedure (instruction-or-info))
  -(defgeneric (setf procedure) (new instruction-or-info))
  +(defgeneric owner (instruction-or-info))
  +(defgeneric (setf owner) (new instruction-or-info))
   (defgeneric basic-block (instruction-or-info))
   (defgeneric (setf basic-block) (new instruction-or-info))
  -(defgeneric pre-locations (instruction-or-info))
  -(defgeneric (setf pre-locations) (new instruction-or-info))
  -(defgeneric post-locations (instruction-or-info))
  -(defgeneric (setf post-locations) (new instruction-or-info))
   
   (defclass instruction-info ()
     (;; The list of predecessor instructions of this instruction. 
  -   (%predecessors :initform nil :accessor predecessors)
  +   (%predecessors :initform '() :accessor predecessors)
      ;; The procedure to which this instruction belongs.
  -   (%procedure :initform nil :accessor procedure)
  +   (%owner :initform nil :accessor owner)
      ;; The basic block to which this instruction belongs.
  -   (%basic-block :initform nil :accessor basic-block)
  -   ;; A set of CONS pairs (location . distance) that are valid
  -   ;; immediatly before this instruction.
  -   (%pre-locations :initform nil :accessor pre-locations)
  -   ;; A set of CONS pairs (location . distance) that are valid
  -   ;; immediatly after this instruction.
  -   (%post-locations :initform nil :accessor post-locations)))
  +   (%basic-block :initform nil :accessor basic-block)))
   
   (defmethod predecessors ((instruction sicl-mir:instruction))
     (assert (not (null *program*)))
  
positive.code: ;;; also referred to by some procedure C inside which both A and B are
  ;;; nested.
  ;;;
  ;;; A lexical location L is said to be PRESENT in a procedure A if and
  ;;; only if some instruction belonging to A refers to L.  A location L
  ;;; is said to BELONG to a procedure A if L is present in A, and L is
  ;;; not present in a procedure inside which A is nested.  Because of
  ;;; the restriction in the previous paragraph, every location belongs
  ;;; to some unique procedure.
  ;;;
  ;;; The LEXICAL DEPTH of a procedure is a quantity that is less than
  ;;; or equal to the NESTING depth of that procedure.  We define it
  
negative.code: 		   (procedures procedures))
        program
      (let ((*program* program))
        (let* ((first (make-procedure initial-instruction 0))
  	     (worklist (list first)))
  	(push first procedures)
  