anchor.diff:    ((%initial :initarg :initial :accessor initial)
      (%final :initarg :final :accessor final)))
   
  -(defun compute-basic-blocks-for-code-object (code-object program)
  +(defun compute-basic-blocks-for-procedure (procedure program)
     (ensure-instruction-ownership program)
  -  (ensure-predecessors program)
     (with-accessors ((instructions instructions)
   		   (basic-blocks basic-blocks))
  -      code-object
  +      procedure
       (let ((remaining instructions))
         (flet ((one-block (instruction)
   	       (let ((initial instruction)
   		     (final instruction))
  -		 (loop for preds = (instruction-predecessors initial program)
  +		 (loop for preds = (predecessors initial)
   		       while (= (length preds) 1)
   		       for pred = (car preds)
  -		       while (eq (instruction-owner pred program) code-object)
  -		       for succs = (p2:successors pred)
  +		       while (eq (procedure pred) procedure)
  +		       for succs = (successors pred)
   		       while (= (length succs) 1)
   		       do (setf initial pred)
   			  (setf remaining (remove pred remaining :test #'eq)))
  -		 (loop for succs = (p2:successors final)
  +		 (loop for succs = (successors final)
   		       while (= (length succs) 1)
   		       for succ = (car succs)
  -		       while (eq (instruction-owner succ program) code-object)
  -		       for preds = (instruction-predecessors succ program)
  +		       while (eq (procedure succ) procedure)
  +		       for preds = (predecessors succ)
   		       while (= (length preds) 1)
   		       do (setf final succ)
   			  (setf remaining (remove succ remaining :test #'eq)))
  
positive.code: ;;; one of the inputs or one of the outputs of I.  
  ;;;
  ;;; A LOCATION can be referred to by several different instructions
  ;;; that belong to code objects at different nesting depths.  Because
  ;;; of the way locations are created, if a location is referred to by
  ;;; two different instructions belonging to two different code
  ;;; objects, A and B, and neither A is nested inside B nor B is nested
  ;;; inside A, then the location is also referred to by some code
  ;;; object C inside which both A and B are nested.
  ;;;
  ;;; A LOCATION L is said to be PRESENT in a code object A if and only
  ;;; if some instruction belonging to A refers to L.  A location L is
  ;;; said to BELONG to a code object A if L is present in A, and L is
  ;;; not present in a code object inside which A is nested.  Because of
  ;;; the restriction in the previous paragraph, every location belongs
  ;;; to some unique code object.
  ;;;
  ;;; The LEXICAL DEPTH of a code object is a quantity that is less than
  ;;; or equal to the NESTING depth of that code object.  We define it
  ;;; recursively as follows: The lexical depth of a code object A such
  ;;; that every location and instruction that is present in A also
  ;;; belongs to A is defined to be 0.  For a code object A with a
  ;;; location or an instruction present in it, but that belongs to a
  ;;; different code object B, let D be the greatest depth of any such
  ;;; code object B.  Then the lexical depth of A is D+1. 
  ;;;
  ;;; A SIMPLE INSTRUCTION CHAIN is a sequence of instructions, all
  ;;; belonging to the same code object such that every instruction in
  ;;; the sequence except the first is the unique successor in the
  ;;; instruction graph of its predecessor in the sequence, and every
  ;;; instruction in the sequence except the last is the unique
  
negative.code: (in-package #:sicl-optimize)
  
  ;;; A LOCATION is an explicit (present in source code) or implicit
  ;;; (allocated by the compiler) lexical "place" used to store local
  ;;; variables and temporaries.  Locations are not directly used as
  